Role mutable file system

ABSTRACT

A role mutable file system provides high availability processing of network requests with systems that can seamlessly switch between server and client operational roles. The file system includes a replicated storage pool associated with each server/client system where only the storage pool of the system in the server role is active. A role mutable file system (RMFS) manager on each system seamlessly switches roles between server and client to service network requests from either system to prevent interruption of service to system users.

BACKGROUND 1. Technical Field

This disclosure generally relates to computer data storage systems, and more specifically relates to a role mutable file system for high availability data storage that provides uninterrupted network request processing.

2. Background Art

Data storage systems seek to provide efficient data storage with high availability to insure data is always available when a customer needs the data. High availability means availability despite planned outages for upgrades or unplanned outages caused by hardware or software failures. Many different systems incorporate various methods to achieve high availability including database backup and duplication, failover systems, memory and storage replication, etc.

Data storage systems often include a data server/client system where a server responds to data requests from a user or customer applications on a client system. When a server fails or needs to be taken off-line it is desirable for the file system to be able to continuously respond to data requests from the applications.

BRIEF SUMMARY

A role mutable file system provides high availability processing of network requests with systems that can seamlessly switch between server and client operational roles. The file system includes a replicated storage pool associated with each server/client system where only the storage pool of the system in the server role is active. A role mutable file system (RMFS) manager on each system seamlessly switches roles between server and client to service network requests from either system to prevent interruption of service to system users.

The foregoing and other features and advantages will be apparent from the following more particular description, as illustrated in the accompanying drawings.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWING(S)

The disclosure will be described in conjunction with the appended drawings, where like designations denote like elements, and:

FIG. 1 is a block diagram of a computer system with a role mutable file system manager;

FIG. 2 illustrates another simplified block diagram of a role mutable file system with a first system in the server role and a second system in the client role;

FIG. 3 illustrates the role mutable file system of FIG. 2 after mutation of the role of the two RMFS managers;

FIG. 4 illustrates the role mutable file system of FIG. 2 after detection of a failure event and the mutation coordinator swapping roles of the RMFS managers;

FIG. 5 illustrates examples of system attributes;

FIG. 6 illustrates examples of application attributes;

FIG. 7 illustrates examples of user configurations;

FIG. 8A and FIG. 8B show an example of updating an object structure when an RMFS is mutated from a client role to a server role;

FIG. 9 is a flow diagram of a method performed by a role mutable file system manager; and

FIG. 10 is a flow diagram of a specific method for step 930 in FIG. 9.

DETAILED DESCRIPTION

The disclosure and claims herein relate to a system and method for a role mutable file system that provides high availability processing of network requests with systems that can seamlessly switch between server and client operational roles. The file system includes a replicated storage pool associated with each server/client system where only the storage pool of the system in the server role is active. A role mutable file system (RMFS) manager on each system seamlessly switches roles between server and client to service network requests from either system to prevent interruption of service to system users.

Referring to FIG. 1, a computer system 100 is one suitable implementation of a computer system that is capable of performing the computer operations described herein including a role mutable file system manager 123. Computer system 100 is a computer which can run multiple operating systems including the IBM i operating system. However, those skilled in the art will appreciate that the disclosure herein applies equally to any computer system, regardless of whether the computer system is a complicated multi-user computing apparatus, a single user workstation, laptop, phone or an embedded control system. As shown in FIG. 1, computer system 100 comprises one or more processors 110. The computer system 100 further includes a main memory 120, a mass storage interface 130, a display interface 140, and a network interface 150. These system components are interconnected through the use of a system bus 160. Mass storage interface 130 is used to connect mass storage devices with a computer readable medium, such as mass storage 155, to computer system 100. One specific type of mass storage 155 is a readable and writable CD-RW drive, which may store data to and read data from a CD-RW 195. Some mass storage devices may have a removable memory card or similar instead of the CD-RW drive.

Main memory 120 preferably contains an operating system 121. Operating system 121 is a multitasking operating system known in the industry as IBM i; however, those skilled in the art will appreciate that the spirit and scope of this disclosure is not limited to any one operating system. The memory 120 further includes one or more applications 122. The memory 120 also includes a role mutable file system manager 123 that includes a mutation coordinator 124, application attributes 125, and user configurations 126. The memory may also include system attributes 127.

Computer system 100 utilizes well known virtual addressing mechanisms that allow the programs of computer system 100 to behave as if they only have access to a large, single storage entity instead of access to multiple, smaller storage entities such as main memory 120 and mass storage 155. Therefore, while operating system 121, applications 122, RMFS manager 123, mutation coordinator 124, application attributes 125, user configurations 126 and system attributes 127 are shown to reside in main memory 120, those skilled in the art will recognize that these items are not necessarily all completely contained in main memory 120 at the same time. It should also be noted that the term “memory” is used herein generically to refer to the entire virtual memory of computer system 100, and may include the virtual memory of other computer systems coupled to computer system 100.

Although computer system 100 is shown to contain only a single processor and a single system bus, those skilled in the art will appreciate that the system may be practiced using a computer system that has multiple processors and/or multiple buses. In addition, the interfaces that are used preferably each include separate, fully programmed microprocessors that are used to off-load compute-intensive processing from processor 110. However, those skilled in the art will appreciate that these functions may be performed using I/O adapters as well.

Display interface 140 is used to directly connect one or more displays 165 to computer system 100. These displays 165, which may be non-intelligent (i.e., dumb) terminals or fully programmable workstations, are used to provide system administrators and users the ability to communicate with computer system 100. Note, however, that while display interface 140 is provided to support communication with one or more displays 165, computer system 100 does not necessarily require a display 165, because all needed interaction with users and other processes may occur via network interface 150, e.g., web client based users.

Network interface 150 is used to connect computer system 100 to other computer systems or workstations 175 via network 170. Network interface 150 broadly represents any suitable way to interconnect electronic devices, regardless of whether the network 170 comprises present-day analog and/or digital techniques or via some networking mechanism of the future. In addition, many different network protocols can be used to implement a network. These protocols are specialized computer programs that allow computers to communicate across a network. TCP/IP (Transmission Control Protocol/Internet Protocol) is an example of a suitable network protocol.

The present invention may be a system, a method, and/or a computer program product at any possible technical detail level of integration. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.

The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non- exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.

Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.

Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, configuration data for integrated circuitry, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++, or the like, and procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.

These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.

The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the Figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.

FIG. 2 illustrates a simplified example of a role mutable file system 200 that provides high availability processing of network requests by seamlessly switching between server and client operational roles as described herein. The role mutable filesystem 200 in the illustrated example includes computer systemA 100A connected to computer systemB 100B by a communication link 210. Computer systemA 100A and computer systemB 100B are similar to the computer system 100 described above with reference to FIG. 1. Computer systemA 100A includes one or more applications 122A and an RMFS manager 123A. Similarly, computer system 100B includes one or more applications 122B and an RMFS manager 123B. Computer systemA 100A is connected through connection 222 to storage pool A 220A while computer system 100B is connected through connection 224 to storage pool B 220B. The connections 222, 224 may include physical connections as well as logical layer and physical layers of system software. The contents of storage pools 220A, 220B are mirrored to hold the same data, preferably by hardware replication 226 in a manner known in the prior art. FIG. 2 illustrates a system with just two computer systems as a simplified example. It would be understood by one of ordinary skill in the art that the system could be extended to any number of computer systems. Further, there could be multiple storage pools and associated RMFS managers in the server role on a single computer system. For simplicity the following examples show a single RMFS manager in the server role.

The RMFS managers 123A, 123B preferably operate at any given time in one of three roles, namely, server, client and stand-alone roles. As referred to herein, a server file system is one where the RMFS manager operates in the server role. The RMFS manager that is configured to the storage drive/pool that is currently active is placed in the server role. The RMFS manager in the server role handles all local requests that originate on that system for operations intended to run against or manipulate the configured storage pool. Additionally the RMFS in the server role will receive requests from one or more paired systems with the RMFS in the client role. Thus the server file system in the server role will handle requests that were intended for the target storage pool which originated from the other system(s). All requests are physically fulfilled by the RMFS manager in the server role. Responses will be sent back to the file system(s) in the client role.

As referred to herein, a client file system is one where the RMFS manager is in the client mode. One or more other file system computers may have an RMFS manager in the client role and while in this role are designated as client file systems. The configured target storage pools in the client file systems are always inactive on their respective system. The target storage pool that is active and associated with the server file system will appear to be local and accessible to the end users from each of the client file systems. Requests that originate from a client file system intended to operate against the storage pool will pass through a communication link to the server file system and physically processed on that system. The response and outcome of the server side processing is received by the client and passed back to the user. From the user's point of view, the operation took place locally on the client file system.

RMFS managers may also operate in a stand-alone role or mode. The stand-alone role occurs when the computer systems in the role mutable file system become detached. This may occur if the configured pairing of the RMFS managers is intentionally disassociated such that they no longer operate as a pair. In this case, the configured storage pool on each system can become active and operate independently on each system. In this mode, each RMFS manager will act as if it is a solitary system in local mode only. Once the link is re-attached, the relationship between the systems is reestablished based on a previous configuration such that each system will mutate to its appropriate server or client role.

The role mutable file system 200 in FIG. 2 is shown in an initial state. FIG. 3 and FIG. 4 represent the same system in subsequent states as described below. In FIG. 2, the RMFS manager 123A is in the server role and the RMFS manager 123B is in the client role. With the RMFS manager 123A in the server role, the RMFS manager 123A handles file server requests 228 directly from applications 122A. File server requests 230 from applications 122B are initially processed through the RMFS manager 123B in the client role and then sent to the RMFS manager 123A over the communication link 210. The RMFS manager 123A then processes the file server requests to the active storage pool 220A. Thus all file server requests from the applications are handled by the RMFS manager 123A acting in the server role which is accessing the active server pool 220A that is continuously replicated to the inactive server pool 220B. The connection 224 to the inactive storage pool 220B is shown as a broken line to indicate the connection is not active. The role mutable file system 200 will continue in this state until there is an event that triggers the RMFS managers to mutate roles. The events that may trigger the mutations are described further below. The RMFS managers 123A and 123B monitor for mutation events, and when the RMFS managers detect a trigger event, the RMFS managers instruct the mutation coordinator to seamlessly change or mutate their role from client to server, or server to client as described further below.

FIG. 3 represents the role mutable file system 200 as shown in FIG. 2 after detection of an event and then the mutation coordinator swapping roles of the RMFS managers. The process of the mutation coordinators swapping roles is described in further detail below. In FIG. 3, the RMFS manager 123A has mutated to the client role and the RMFS manager 123B has mutated to the server role. The RMFS manager 123B that is in the server role is connected to the now active storage pool 220B via connection 224. The RMFS manager 123A that is now in the client role remains connected to the now inactive storage pool 220A, via the connection 222 which is shown as a broken line to indicate the connection is not active. The RMFS manager 123A must now access the active storage pool 220B through the link 210 and the RMFS manager 123B in the server role.

FIG. 4 represents the role mutable file system 200 as shown in FIG. 2 after detection of an event and the mutation coordinator swapping roles of the RMFS managers. In this example, it is assumed that the event was a failure of systemA 100A. This failure was detected by the RMFS manager 123B in system 100B. The RMFS manager 123B then requested the mutation coordinator 124B to mutate. The mutation coordinator 124B determined to mutate to a server role as shown. SystemA 100A is shown crossed out to indicate the system is not operational. Similarly the communication link 210 and the replication link 226 may also be non-operational due to systemA 100A being down.

There are three primary types of events that may result in a role mutation: system failure, communication link issues and application/product driven events. System failure events may include a primary system crash that takes down the RMFS manager running in server role. The event would be detected by the RMFS manager on the secondary system (client role) and it would trigger the mutation. The secondary system's RMFS would then mutate from client role to server role. When the system with the RMFS manager that previously operated in the server role recovers, the RMFS manager on this system will query the system attributes to realize that it previously crashed and it was a server mode RMFS and it now needs to return to operation as a client mode RMFS manager. The system attributes are described further below.

Communication Link Issues. If a problem is detected with the network communication infrastructure between the two systems (and the two RMFS), a configurable timeout may be used to allow communication to be re-established. This would allow the RMFS Manager and the system a chance to resolve the problem should it be a quick intermittent issue. If the timeout expires (network problem did not resolve itself in quick fashion), then the RMFS could mutate accordingly to the user configuration.

Application/Product driven events. The RMFS manager may be configured or integrated as part of an application, product or system. The RMFS manager may be explicitly told to mutate to a specific mode. For example, the RMFS manager may be instructed to do a planned role swap. In this example, the RMFS manager running in server role will become a client and the RMFS manager running as a client role will become a server. Preferably the mutation will take place in a simultaneous coordinated fashion on both systems. In a second example, the RMFS manager may be instructed to mutate to the stand-alone role. In this example, an application/system/product may instruct the RMFS managers to uncouple the RMFS system pair with the storage pool pair and run each RMFS manager in stand-alone role.

As introduced above, system attributes may be stored and used by the RMFS manager 123. For example, system attributes 127 may be stored in the system memory 120 as shown in FIG. 1. The system attributes may be maintained by the operating system 121 or other software in the system. The system attributes 127 may be used by the RMFS manager 123 to determine historical details and preferences. An example of system attributes 127 and their associated values are shown in FIG. 5. Similarly, the RMFS manager 123 may also use application attributes 125 as shown in FIG. 1. Examples of application attributes 125 are shown in FIG. 6. The application attributes 125 may be maintained by the RMFS manager 123 or other software in the system. In this example, the application attributes 125 are stored with the RMFS manager 124.

Using the example attributes in the tables above, the RMFS manager 123 could determine that there was a system crash and that the system is just starting back up since there are cleanup items that are required and startup processing has not finished yet. The RMFS manager can determine what role the RMFS manager 123 was previously in and that the RMFS manager needs to mutate to a new role. In this example the RMFS manager 123 could also key off of the application attribute MutateAfterSystemCrash to tell the RMFS manager what action to take, i.e. whether to mutate to server, mutate to client, stay the same or mutate to opposite of the previous role.

As introduced above, the RMFS manager may use user configurations 126 that allow the user to set configuration preferences on how the RMFS manager is to operate under given conditions. The user configuration may be set by a user/administrator using a graphical user interface. The user configurations may be set in an application 122 that is associated with the role mutable file system. Examples of user configurations are shown in FIG. 7. Example user configurations include how long to time out for a connection outage to then execute a mutation, and whether to notify an administrator for a connection outage.

As introduced above, mutation is when the file system changes its role and operation type seamlessly in-flight and in coordination with the overall environmental scenario. Examples of mutation include a role swap occurring on both systems which could occur for system maintenance. Mutation could also occur in system down scenarios where a file system needs to mutate into a server role because the original server role system has failed. Again, this mutation is seamless such that the user is not aware that a mutation is occurring. When an event occurs that requires a mutation, this information may be relayed to a mutation coordinator. The mutation coordinator contains intelligence to use event-combination analysis to determine the current scenario such as a planned failover, system down or user initiated mutation. The mutation coordinator can query the outside environment to gain additional awareness of the overall systems' states. For example, the mutation coordinator can reference the system attributes, application attributes and user configurations described above. Once the situation is determined, mutation coordinator may then mutate the mount structures on both systems accordingly. Unlike traditional mounting and unmounting, the mutation herein does not tear down the mount structures but leaves them in a partial state for the role change. Once mutation begins, the mutation coordinator will begin executing pre-defined actions, based on role, to mount each file system again. The mount structures are then filled out to completion in respect to their role type and the new “mount” is finished. The nodes that logically track and manage objects in this environment are also updated to reflect their residing system's new role.

Additional details of the mutation coordinator will now be described. The mutation coordinator receives a signal from the RMFS manager to begin mutation. This signal could contain information on the target mode as well as a scenario indicator. For example, the signal may take the form:

MsgToMutationCoordinator::action=Mutate::currentMode=Client::targetMode=Server::r easonCode=primarySysFailure

After receiving the signal to commence mutation, the mutation coordinator begins to handle inflight communication operations. For example, the mutation coordinator could allow all operations in process or “in-flight” to progress to the nearest synchronization point or operation boundary. After handling operations in-flight, the mutation coordinator may then issue an instruction to halt operations. For example, the mutation coordinator may issue a stop-lock instruction to the RMFS managers to communicate with software applications where the software applications each check the stop lock instruction to know whether it is safe to proceed. The enforcement of this stop-lock will halt any new operations from starting to process. Stop-locks are known in the prior art. An example of a stop lock could be a condition mechanism in which all the operations would check and react to a condition either by waiting or proceeding with the operation.

After the stop-lock instruction, if the operation is a planned role swap, the storage pool that is active is turned off and placed into inactive state such that both storage pools are then inactive. The mutation coordinator then triggers code that begins changing the state of the RMFS manager. This could be done by sending a message to the RMFS manager. The mutation coordinator or the RMFS manager then updates internal structures for the new state of the RMFS manager. When file systems are unmounted, in traditional file systems they typically tear down the associated mount structures that mounted the storage pools. For the RMFS manager running in server mode, these mount structures associated to the storage pools are not taken down but left in a skeleton state. Internal software structures are updated to reflect the new mode. In this case, the new server RMFS manager will fill out its skeleton mount structures in preparation for the activation of the storage pools on that system. The skeleton state means that during a mutation the structures are only partially torn down. When the mutation finishes and the role is known the skeleton mount structure can be completed. During this process, the skeleton structures would be very similar to FIGS. 8A and 8B in that some fields of the structure are known and filled in and others are blank or have a placeholder value. The skeleton structure may be filled in with completed data at a later time.

The mutation coordinator may then initiate a process to handle individual objects as described further below. The communication network is then refreshed and the mutation coordinator activates the storage pools connected to the RMFS manager in the server role. An Acknowledgement is sent over a system messaging framework to other components in the system that the new server RMFS manager is ready. The mutation coordinator releases the “Stop Lock” and issues a “Go Lock”. This will allow new operations that were held due to the “Stop Lock” to now proceed. Inflight operation handling occurs to process those operations that were held in synchronization boundary points.

In some embodiments, the mutation coordinator 124 may need to process individual object structures stored in memory to reflect the current mode or role of the of the computer system or virtual node they reside in. As described above, data objects for both the client and server are stored in the replicated storage pool. However, object structures for these data objects are often stored in memory and managed by the operating system. The object structures include data related to the data objects to enable the applications to access the data objects stored in the storage pool. Thus there could be object structures related to the data objects in the storage pool in both the client and server system memory. In the illustrated example, these object structures would normally be stored in memory 120 by the operating system 121 shown in FIG. 1. The object structures may need to be processed and updated in relation to their access role. For example, objects being tracked on a client role RMFS are really “Ghost” objects since the real object exists on the system of the server role RMFS. The object structures on the client RMFS system are filled-in and converted to store and house the actual attributes of the real object when the RMFS is converted to the server role. An example of this conversion is described below.

FIG. 8A and FIG. 8B show an example of updating an object structure on system 100B when the RMFS manager 123B is mutated from a client role (FIG. 2) to a server role (FIG. 3). FIG. 8A represents a simplified object structure 810A for a PDF file named “MyFile.pdf”. An actual object structure may contain other fields not shown here. The PDF file is stored in the storage pool described above while the object structure 810A is stored in memory of the computer system 100B in FIG. 2. The object memory address 812A maps to a physical memory location on the storage pool 220. Since this object structure is located in systemB 100B, this means the data object on storage pool 220B is not accessible from this system. For any operations that manipulate this object, they would have to be sent as a request to the RMFS manager 123A on the server side 100A. The object structure field RMFSObject=yes 814A indicates that associated object is managed by the RMFS. The object structure field RMFSType 816A indicates that the current role is client. The client structure field VnodeType 818A indicates that the current virtual node of on systemB 100B is a client virtual node.

FIG. 8B shows an example of the updated object structure 810B after the system 100B is mutated from a client role to a server role. In this example, we assume the RMFS manager for this system has been instructed to mutate to a RMFS server role. This object will be processed along with all objects that are indicated to be client RMFS objects. These objects are processed to update their fields to reflect the new role of the RMFS manager for the associated computer system. Also, where client object structures are updated to server object structures, the “real” values need to be materialized and placed into the structure. In this example, the object structure in FIG. 8A is modified to reflect the object structure in FIG. 8B in conjunction with the RMFS manager mutating from the client role to the server role. Thus, the RMFS type 816B is changed to “Server”, and the Vnode type is changed to “Server Vnode” 818B. The Vnode structure data 820B is copied from the corresponding object structure on computer systemA 100A where the corresponding RMFS manager 123A was previously in the server role. Similarly, the object structures on systemA 100A would be modified to values as shown in FIG. 8A where the RMFS manager 123A on systemA 110A is mutated from the server role to the client role as shown in FIG. 3.

As introduced above with reference to FIG. 2, the RMFS managers 123A, 123B are each configured to a respective storage pool 220A, 220B. The storage pools 220 may be a single storage drive or an independent storage pool of drives. One example of an independent storage pool is an Independent Auxiliary Storage Pool (IASP) as known in the art. The storage pools are identically named and only a single storage pool is physically active at any given time. The pools are kept in synchronization and completely identical by suitable hardware replication technology known in the prior art.

The communication link 210 was introduced above with reference to FIG. 2. The communication link 210 is a high speed data link between the RMFS managers 123. The communication link 210 may be implemented in the communications network layer of the system software. An example of the communication link is a Remote Direct Memory Access (RDMA) on Converged Ethernet (RoCE) as known in the prior art.

Referring to FIG. 9, a method 900 shows one suitable example for a role mutable file system that provides high availability processing of network requests with systems that can seamlessly switch between server and client operational roles. Portions of method 900 are preferably performed by the RMFS managers 123A and 123B shown in FIG. 2. First, monitor the system for mutation events (step 910). If an event is not detected (step 920=no) then return to step 910. If an event is detected (step 920=yes) then mutate the role mutable file system (step 930). Control may then return to step 910.

FIG. 10 shows one suitable example of a method to mutate the role mutable file system. Method 1000 thus shows a suitable method for performing step 930 in method 900 in FIG. 9. First, receive a signal to mutate the role (step 1001). Handle in-flight operations (step 1002). Issue stop-lock to halt operations (step 1003). Issue stop lock to halt operations (step 1003). Inactivate storage pools while keeping mount structures (step 1004). Instruct RMFS managers to change internal state (step 1005). Update internal structures for new state (step 1006). Initiate process to handle individual objects (step 1007). Refresh communication network in new state (step 1008). Activate storage pools (step 1009). Communicate with system that the role mutable file system is ready (step 1010). Release the stop lock (step 1011). Complete in-flight operations held at boundary points (step 1012). The method 1000 is then done.

This disclosure describes a role mutable file system that provides high availability processing of network requests with systems that can seamlessly switch between server and client operational roles. The file system accesses a replicated storage pool associated with each server/client system where only the storage pool of the system in the server role is active.

One skilled in the art will appreciate that many variations are possible within the scope of the claims. Thus, while the disclosure is particularly shown and described above, it will be understood by those skilled in the art that these and other changes in form and details may be made therein without departing from the spirit and scope of the claims. 

1. A computer apparatus comprising: a first computer system with a first processor, a first memory coupled to the first processor, a first role mutable file system (RMFS) manager residing in the first memory and executed by the first processor, wherein the first computer system is connected to a first storage pool; a second computer system with a second processor, a second memory coupled to the second processor, a second role mutable file system (RMFS) manager residing in the second memory and executed by the second processor, wherein the second computer system is connected to a second storage pool that is a replicated copy of the first storage pool, wherein the second RMFS manager communicates with the first RMFS manager through a communication link; in an initial state the first RMFS manager performs in a server role to respond to file service requests from a first application in the first memory and to respond to file service requests from a second application in the second memory where file service requests from the second application come through the second RMFS manager in a client role, wherein the first RMFS manager services the file service requests with data from the first storage pool that is active while the second storage pool is inactive in the initial state; and upon detecting one of a plurality of events, the first RMFS manager and the second RMFS manager mutate to a second state, wherein the first RMFS manager mutates to the client role, the second RMFS manager mutates to the server role to respond to file service requests from the second application on the second computer system and to respond to file service requests from the first applications on the first computer system through the first RMFS manager now in the client role, wherein the first storage pool is made inactive and the second storage pool is made active in the second state.
 2. The computer apparatus of claim 1 wherein the first storage pool and the second storage pool are an Independent Auxiliary Storage Pool (IASP).
 3. The computer apparatus of claim 1 wherein the communications link is a high speed data link implemented in a communications network layer of system software on the first computer system and the second computer system.
 4. The computer apparatus of claim 3 wherein the high speed data link is a Remote Direct Memory Access (RDMA) on Converged Ethernet (RoCE) communications link.
 5. The computer apparatus of claim 1 wherein the plurality of events comprise: a system failure, a communication link issue, and an application/product driven event.
 6. The computer apparatus of claim 1 wherein the RMFS managers process individual object structures in memory to reflect the mutation to the second state.
 7. The computer apparatus of claim 6 wherein the first and second RMFS managers process individual object structures in the first and second memory to reflect the mutation to the second state by changing an object structure that indicates RMFS type from “client” to “server”.
 8. The computer apparatus of claim 1 wherein the first and second RMFS managers handle in-flight operations while transitioning from the first state to the second state.
 9. The computer apparatus of claim 1 wherein the first and second RMFS managers issue a stop lock while transitioning from the first state to the second state.
 10. A computer-implemented method executed by at least one processor that provides high availability processing of network requests for a role mutable file system comprising: monitoring the system for mutation events; in response to a detected event, mutating the role mutable file system by switching a first role mutable file system (RMFS) manager on a first system from a server role to a client role and switching a second role mutable file system (RMFS) manager on a second system from the client role to the server role; wherein the second RMFS manager communicates with the first RMFS manager through a communication link.
 11. The method of claim 10 wherein mutating the role mutable file system further comprises: receiving a signal to mutate the RMFS; and handling in-flight operations.
 12. The method of claim 11 further comprising issuing a stop lock to halt operations.
 13. The method of claim 12 further comprising inactivating storage pools while keeping mount structures.
 14. The method of claim 13 further comprising instructing the first and second RMFS managers to change internal states
 15. The method of claim 14 further comprising: refreshing the communication network in second state; activating the storage pools; communicating with the system that the first and second RMFS managers are ready; and releasing the stop lock.
 16. The method of claim 14 further comprising completing in-flight operations held at boundary points.
 17. The method of claim 10 wherein the mutation events comprise: a system failure, a communication link issue, and an application/product driven event.
 18. The method of claim 10 wherein the first and second RMFS managers process individual object structures to reflect mutation the role by changing an object structure that indicates RMFS type from “client” to “server”.
 19. The method of claim 10 wherein the communications link is implemented in a communications network layer of system software with a Remote Direct Memory Access (RDMA) on Converged Ethernet (RoCE) communications link.
 20. A computer-implemented method executed by at least one processor that provides high availability processing of network requests for a role mutable file system comprising: monitoring the system for mutation events; in response to a detected mutation event, mutating the role mutable file system by switching a first role mutable file system (RMFS) manager on a first system from a server role to a client role and switching a second role mutable file system (RMFS) manager on a second system from the client role to the server role; wherein the second RMFS manager communicates with the first RMFS manager through a communication link; wherein mutating the role mutable file system further comprises: receiving a signal to mutate the RMFS; handling in-flight operations; issuing a stop lock to halt operations; inactivating storage pools while keeping mount structures; instructing the first and second RMFS managers to change internal states; process individual object structures to reflect mutation the role by changing an object structure that indicates RMFS type from “client” to “server”; refreshing the communication network in second state; activating the storage pools; communicating with the system that the first and second RMFS managers are ready; releasing the stop lock; and completing in-flight operations held at boundary points. 